/**
 * cornerstoneService.js
 * 提供医学影像查看器的Cornerstone库初始化和工具管理功能
 * 从ViewerPage.vue中提取，专注于Cornerstone相关的底层功能
 */

import cornerstone from 'cornerstone-core';
import cornerstoneMath from 'cornerstone-math';
import cornerstoneTools from 'cornerstone-tools';
import cornerstoneWADOImageLoader from 'cornerstone-wado-image-loader';
import dicomParser from 'dicom-parser';
import Hammer from 'hammerjs';

/**
 * 初始化Cornerstone库及其依赖
 * 配置Cornerstone核心库、工具和图像加载器
 * @returns {Promise<boolean>} 初始化成功返回true，失败返回false
 */
export async function initializeCornerstone() {
  try {
    console.log('初始化 Cornerstone 库...');
    
    // 设置外部依赖
    console.log('设置 Cornerstone 外部依赖...');
    cornerstoneTools.external.cornerstone = cornerstone;
    cornerstoneTools.external.cornerstoneMath = cornerstoneMath;
    cornerstoneTools.external.Hammer = Hammer;
    
    // 初始化工具
    console.log('初始化 Cornerstone 工具...');
    cornerstoneTools.init({
      showSVGCursors: true,
      mouseEnabled: true,
      touchEnabled: true
    });
    
    // 注册必要的工具
    console.log('注册 Cornerstone 工具...');
    cornerstoneTools.addTool(cornerstoneTools.StackScrollTool);
    cornerstoneTools.addTool(cornerstoneTools.StackScrollMouseWheelTool);
    cornerstoneTools.addTool(cornerstoneTools.ZoomTool);
    cornerstoneTools.addTool(cornerstoneTools.PanTool);
    cornerstoneTools.addTool(cornerstoneTools.WwwcTool);
    
    // 配置WADO图像加载器
    console.log('配置 WADO 图像加载器...');
    cornerstoneWADOImageLoader.external.cornerstone = cornerstone;
    cornerstoneWADOImageLoader.external.dicomParser = dicomParser;
    
    // 优化图像加载器配置
    const config = {
      maxWebWorkers: Math.max(navigator.hardwareConcurrency || 4, 4), // 使用至少4个Web Worker
      startWebWorkersOnDemand: false, // 立即启动Web Worker
      webWorkerTaskPriority: 5, // 提高Web Worker任务优先级
      taskConfiguration: {
        decodeTask: {
          initializeCodecsOnStartup: true,
          strict: false // 非严格模式可能更快
        }
      }
    };
    
    cornerstoneWADOImageLoader.webWorkerManager.initialize(config);
    
    // 注册图像加载器
    cornerstone.registerImageLoader('wadouri', cornerstoneWADOImageLoader.wadouri.loadImage);
    
    console.log('Cornerstone 初始化完成');
    return true;
  } catch (error) {
    console.error('初始化 Cornerstone 失败:', error);
    return false;
  }
}

/**
 * 启用Cornerstone元素
 * @param {HTMLElement} element - 要启用的DOM元素
 * @returns {Promise<boolean>} 成功返回true，失败返回false
 */
export async function enableElement(element) {
  if (!element) {
    console.error('无法启用Cornerstone元素: 元素未定义');
    return false;
  }
  
  try {
    // 检查元素是否已启用
    try {
      cornerstone.getEnabledElement(element);
      console.log('元素已启用，跳过初始化');
      return true;
    } catch (e) {
      // 元素未启用，继续启用流程
    }
    
    // 启用元素
    cornerstone.enable(element);
    
    return true;
  } catch (error) {
    console.error('启用Cornerstone元素失败:', error);
    return false;
  }
}

/**
 * 为元素添加Cornerstone工具
 * @param {HTMLElement} element - 要添加工具的DOM元素
 * @param {Array<string>} imageIds - 图像ID数组
 * @returns {boolean} 成功返回true，失败返回false
 */
export function addCornerstoneTools(element, imageIds = []) {
  if (!element) {
    console.error('无法添加Cornerstone工具: 元素未定义');
    return false;
  }
  
  try {
    // 创建堆栈状态管理器
    const stack = {
      currentImageIdIndex: 0,
      imageIds: imageIds
    };
    
    // 将堆栈状态添加到元素
    try {
      // 添加工具状态
      cornerstoneTools.addToolState(element, 'stack', stack);
      
      // 设置默认工具
      cornerstoneTools.setToolActive('StackScrollMouseWheel', {});
      cornerstoneTools.setToolActive('StackScroll', { mouseButtonMask: 1 });
      
      return true;
    } catch (toolError) {
      console.error('添加工具状态失败:', toolError);
      return false;
    }
  } catch (error) {
    console.error('添加Cornerstone工具失败:', error);
    return false;
  }
}

/**
 * 设置活动工具
 * @param {HTMLElement} element - 视口元素
 * @param {string} toolName - 工具名称
 * @returns {boolean} 成功返回true，失败返回false
 */
export function setActiveTool(element, toolName) {
  if (!element) {
    console.error('无法设置活动工具: 元素未定义');
    return false;
  }
  
  try {
    // 禁用所有工具
    cornerstoneTools.setToolDisabled('StackScroll');
    cornerstoneTools.setToolDisabled('Pan');
    cornerstoneTools.setToolDisabled('Zoom');
    cornerstoneTools.setToolDisabled('Wwwc');
    cornerstoneTools.setToolDisabled('StackScrollMouseWheel');
    
    // 启用选定的工具
    if (toolName === 'StackScroll') {
      cornerstoneTools.setToolActive('StackScroll', { mouseButtonMask: 1 });
      cornerstoneTools.setToolActive('StackScrollMouseWheel', {});
    } else if (toolName === 'Zoom') {
      cornerstoneTools.setToolActive('Zoom', { mouseButtonMask: 1 });
      cornerstoneTools.setToolActive('StackScrollMouseWheel', {});
    } else if (toolName === 'Pan') {
      cornerstoneTools.setToolActive('Pan', { mouseButtonMask: 1 });
      cornerstoneTools.setToolActive('StackScrollMouseWheel', {});
    } else if (toolName === 'WwwcTool') {
      cornerstoneTools.setToolActive('Wwwc', { mouseButtonMask: 1 });
      cornerstoneTools.setToolActive('StackScrollMouseWheel', {});
    }
    
    return true;
  } catch (error) {
    console.error('设置活动工具失败:', error);
    return false;
  }
}

/**
 * 重置视图
 * @param {HTMLElement} element - 视口元素
 * @returns {boolean} 成功返回true，失败返回false
 */
export function resetView(element) {
  if (!element) {
    console.error('无法重置视图: 元素未定义');
    return false;
  }
  
  try {
    cornerstone.reset(element);
    return true;
  } catch (error) {
    console.error('重置视图失败:', error);
    return false;
  }
}

/**
 * 调整窗宽窗位
 * @param {HTMLElement} element - 视口元素
 * @param {number} widthDelta - 窗宽调整量
 * @param {number} centerDelta - 窗位调整量
 * @returns {boolean} 成功返回true，失败返回false
 */
export function adjustWindowLevel(element, widthDelta, centerDelta) {
  if (!element) {
    console.error('无法调整窗宽窗位: 元素未定义');
    return false;
  }
  
  try {
    // 获取当前视口
    const viewport = cornerstone.getViewport(element);
    
    // 调整窗宽窗位
    viewport.voi.windowWidth += widthDelta;
    viewport.voi.windowCenter += centerDelta;
    
    // 确保窗宽为正值
    if (viewport.voi.windowWidth < 1) {
      viewport.voi.windowWidth = 1;
    }
    
    // 更新视口
    cornerstone.setViewport(element, viewport);
    return true;
  } catch (error) {
    console.error('调整窗宽窗位失败:', error);
    return false;
  }
}

/**
 * 应用缩放
 * @param {HTMLElement} element - 视口元素
 * @param {number} scaleFactor - 缩放因子
 * @returns {Object|null} 返回更新后的视口或null（如果失败）
 */
export function applyZoom(element, scaleFactor) {
  if (!element) {
    console.error('无法应用缩放: 元素未定义');
    return null;
  }
  
  try {
    // 获取当前视口
    const viewport = cornerstone.getViewport(element);
    
    // 应用缩放
    viewport.scale *= scaleFactor;
    
    // 限制缩放范围
    viewport.scale = Math.max(0.1, Math.min(10.0, viewport.scale));
    
    // 更新视口
    cornerstone.setViewport(element, viewport);
    
    return {
      success: true,
      scale: viewport.scale
    };
  } catch (error) {
    console.error('应用缩放失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

/**
 * 反转图像
 * @param {HTMLElement} element - 视口元素
 * @returns {boolean} 成功返回true，失败返回false
 */
export function invertImage(element) {
  if (!element) {
    console.error('无法反转图像: 元素未定义');
    return false;
  }
  
  try {
    const viewport = cornerstone.getViewport(element);
    viewport.invert = !viewport.invert;
    cornerstone.setViewport(element, viewport);
    return true;
  } catch (error) {
    console.error('反转图像失败:', error);
    return false;
  }
}

/**
 * 获取当前视口信息
 * @param {HTMLElement} element - 视口元素
 * @returns {Object|null} 返回视口信息或null（如果失败）
 */
export function getViewportInfo(element) {
  if (!element) {
    console.error('无法获取视口信息: 元素未定义');
    return null;
  }
  
  try {
    const viewport = cornerstone.getViewport(element);
    return {
      scale: viewport.scale,
      windowWidth: viewport.voi.windowWidth,
      windowCenter: viewport.voi.windowCenter,
      invert: viewport.invert
    };
  } catch (error) {
    console.error('获取视口信息失败:', error);
    return null;
  }
}

/**
 * 调整视图大小
 * @param {HTMLElement} element - 视口元素
 * @returns {boolean} 成功返回true，失败返回false
 */
export function resizeViewer(element) {
  if (!element) {
    console.error('无法调整视图大小: 元素未定义');
    return false;
  }
  
  try {
    cornerstone.resize(element);
    return true;
  } catch (error) {
    console.error('调整视图大小失败:', error);
    return false;
  }
}

/**
 * 设置ResizeObserver监听元素大小变化
 * @param {HTMLElement} element - 视口元素
 * @returns {ResizeObserver|null} 返回ResizeObserver实例或null（如果失败）
 */
export function setupResizeObserver(element) {
  if (!element) {
    console.error('无法设置ResizeObserver: 元素未定义');
    return null;
  }
  
  if (!window.ResizeObserver) {
    console.error('浏览器不支持ResizeObserver');
    return null;
  }
  
  try {
    const resizeObserver = new ResizeObserver(() => {
      if (element && cornerstone.getEnabledElement(element)) {
        cornerstone.resize(element);
      }
    });
    
    resizeObserver.observe(element);
    return resizeObserver;
  } catch (error) {
    console.error('设置ResizeObserver失败:', error);
    return null;
  }
}

/**
 * 清理Cornerstone资源
 * @param {HTMLElement} element - 视口元素
 * @param {ResizeObserver} resizeObserver - ResizeObserver实例
 * @returns {boolean} 成功返回true，失败返回false
 */
export function cleanupCornerstone(element, resizeObserver) {
  try {
    // 移除事件监听器（如果存在）
    if (element) {
      try {
        // 禁用元素
        if (cornerstone.getEnabledElement(element)) {
          cornerstone.disable(element);
        }
      } catch (disableError) {
        console.warn('禁用Cornerstone元素时出错:', disableError);
      }
    }
    
    // 断开ResizeObserver连接
    if (resizeObserver) {
      try {
        resizeObserver.disconnect();
      } catch (error) {
        console.warn('断开ResizeObserver时出错:', error);
      }
    }
    
    // 清空图像缓存
    try {
      cornerstone.imageCache.purgeCache();
    } catch (error) {
      console.warn('清空图像缓存失败:', error);
    }
    
    // 停止所有正在进行的请求
    try {
      cornerstoneWADOImageLoader.wadouri.dataSetCacheManager.purge();
    } catch (error) {
      console.warn('清理WADO加载器失败:', error);
    }
    
    // 清理Web Workers
    try {
      if (cornerstoneWADOImageLoader.webWorkerManager) {
        cornerstoneWADOImageLoader.webWorkerManager.terminate();
      }
    } catch (error) {
      console.warn('终止Web Worker失败:', error);
    }
    
    return true;
  } catch (error) {
    console.error('清理Cornerstone资源失败:', error);
    return false;
  }
}

/**
 * 模拟图像加载器
 * @param {string} imageId - 图像ID
 * @returns {Promise<Object>} 模拟图像对象
 */
export function mockImageLoader(imageId) {
  // 解析图像ID，获取索引
  const index = parseInt(imageId.split('//')[1], 10);
  
  // 创建模拟图像数据
  const width = 512;
  const height = 512;
  const pixelData = new Uint8Array(width * height);
  
  // 填充像素数据
  for (let y = 0; y < height; y++) {
    for (let x = 0; x < width; x++) {
      // 创建一些简单的图案
      pixelData[y * width + x] = (x + y + index * 20) % 256;
      
      // 添加一些线条
      if ((x + index * 20) % 50 < 2 || (y + index * 20) % 50 < 2) {
        pixelData[y * width + x] = 200;
      }
    }
  }
  
  // 创建cornerstone图像对象
  const image = {
    imageId: imageId,
    minPixelValue: 0,
    maxPixelValue: 255,
    slope: 1.0,
    intercept: 0,
    windowCenter: 127,
    windowWidth: 256,
    getPixelData: () => {
      return pixelData;
    },
    rows: height,
    columns: width,
    height: height,
    width: width,
    color: false,
    sizeInBytes: width * height * 4,
    columnPixelSpacing: 1.0,
    rowPixelSpacing: 1.0
  };
  
  return {
    promise: Promise.resolve(image)
  };
}

/**
 * 注册模拟图像加载器
 * @returns {boolean} 成功返回true，失败返回false
 */
export function registerMockImageLoader() {
  try {
    cornerstone.registerImageLoader('mock', mockImageLoader);
    return true;
  } catch (error) {
    console.error('注册模拟图像加载器失败:', error);
    return false;
  }
}

/**
 * 创建模拟图像集
 * @param {number} count - 图像数量
 * @returns {Array<string>} 模拟图像ID数组
 */
export function createMockImageSet(count = 20) {
  const mockImageIds = [];
  for (let i = 0; i < count; i++) {
    mockImageIds.push(`mock://${i}`);
  }
  return mockImageIds;
} 